<template>
  <div id="container">
    <!-- 删除提示信息 -->
  </div>
</template>

<script setup>
import {onMounted, onUnmounted} from "vue";
import AMapLoader from "@amap/amap-jsapi-loader";
import {ElMessage} from "element-plus";

let map = null;
let startMarker = null; // 起点标记
let destinationMarker = null; // 目的地标记
let driving = null; // 驾车路线规划
let distanceText = null; // 路径长度文本标记
let carMarker = null; // 小车标记
let currentRoute = null; // 当前路线
let carAnimation = null; // 小车动画
let fullPolyline = null; // 完整路径线
let passedPolyline = null; // 已走过路径线

onMounted(() => {
  window._AMapSecurityConfig = {
    securityJsCode: "1facfeb2e1a8a8f67eb2205e8709c523",
  };

  AMapLoader.load({
    key: "632805a7c68735c7635c872b28fdf066",
    version: "2.0",
    plugins: ["AMap.Scale", "AMap.Geocoder", "AMap.PlaceSearch", "AMap.Driving", "AMap.GeometryUtil", "AMap.MoveAnimation"],
  })
      .then((AMap) => {
        map = new AMap.Map("container", {
          viewMode: "3D",
          zoom: 16,
          center: [116.397428, 39.90923], // 设置默认中心点
          pitch: 0, // 俯仰角为0，即正视图
          showLabel: true, // 显示地图标注
          features: ['bg', 'point', 'road', 'building'] // 显示背景、标注、道路和建筑物
        });

        // 初始化驾车路线规划（不显示面板）
        driving = new AMap.Driving({
          map: map,
          panel: null, // 不显示路线面板
          hideMarkers: false, // 显示路径点标记
          polyline: {
            strokeColor: "#CCCCCC", // 未走过路径颜色：浅灰色
            strokeOpacity: 0.8, // 线条透明度
            strokeWeight: 6, // 线条宽度
            lineJoin: 'round' // 折线拐点的绘制样式
          }
        });

        // 注意：已删除地图点击事件监听器
        // map.on('click', handleMapClick);
        // map.on('rightclick', handleMapRightClick);
      })
      .catch((e) => {
        console.error('地图加载失败:', e);
        ElMessage.error('地图加载失败，请刷新页面重试');
      });
});

onUnmounted(() => {
  map?.destroy();
});

// 删除处理地图左键点击事件
// const handleMapClick = (e) => {
//   const lnglat = e.lnglat;
//   addStartMarker(lnglat.lng, lnglat.lat);
// };

// 删除处理地图右键点击事件
// const handleMapRightClick = (e) => {
//   const lnglat = e.lnglat;
//   addDestinationMarker(lnglat.lng, lnglat.lat);
// };

// 添加起点标记（显示"起"图标，不显示信息窗口）
const addStartMarker = (lng, lat) => {
  // 清除之前的起点标记
  if (startMarker) {
    startMarker.setMap(null);
  }

  // 创建新的起点标记，使用"起"图标
  startMarker = new window.AMap.Marker({
    position: [lng, lat],
    title: '起点',
    icon: new window.AMap.Icon({
      size: new window.AMap.Size(25, 34),
      image: '//a.amap.com/jsapi_demos/static/demo-center/icons/dir-marker.png',
      imageSize: new window.AMap.Size(135, 40),
      imageOffset: new window.AMap.Pixel(-9, -3)
    }),
    offset: new window.AMap.Pixel(-13, -30),
    map: map
  });

  ElMessage.success('已设置起点位置');

  // 返回起点信息
  return {
    lng: lng,
    lat: lat
  };
};

// 添加目的地标记（显示"终"图标，不显示信息窗口）
const addDestinationMarker = (lng, lat) => {
  // 清除之前的目的地标记
  if (destinationMarker) {
    destinationMarker.setMap(null);
  }

  // 创建新的目的地标记，使用"终"图标
  destinationMarker = new window.AMap.Marker({
    position: [lng, lat],
    title: '目的地',
    icon: new window.AMap.Icon({
      size: new window.AMap.Size(25, 34),
      image: '//a.amap.com/jsapi_demos/static/demo-center/icons/dir-marker.png',
      imageSize: new window.AMap.Size(135, 40),
      imageOffset: new window.AMap.Pixel(-95, -3)
    }),
    offset: new window.AMap.Pixel(-13, -30),
    map: map
  });

  ElMessage.success('已设置目的地位置');

  // 返回目的地信息
  return {
    lng: lng,
    lat: lat
  };
};

// 极简路径点函数 - 根据距离分情况优化（使用迭代方式避免栈溢出）
const simplifyPath = (path, distanceKm) => {
  let minDistance;

  // 根据距离确定简化程度
  if (distanceKm <= 5) {
    // 5公里以内（市区物流）- 保持最高精度（每10米一个点）
    minDistance = 10;
  } else if (distanceKm <= 50) {
    // 5-50公里（省内物流）- 高精度（每25米一个点）
    minDistance = 25;
  } else if (distanceKm <= 200) {
    // 50-200公里（省内长距离）- 中等精度（每50米一个点）
    minDistance = 50;
  } else if (distanceKm <= 500) {
    // 200-500公里（跨省物流）- 适度简化（每100米一个点）
    minDistance = 100;
  } else if (distanceKm <= 1000) {
    // 500-1000公里（跨省远距离）- 较大简化（每200米一个点）
    minDistance = 200;
  } else {
    // 1000公里以上（全国范围）- 大幅简化（每500米一个点）
    minDistance = 500;
  }

  if (path.length <= 2) return [path[0], path[path.length - 1]];

  const simplified = [path[0]];
  let lastPoint = path[0];

  for (let i = 1; i < path.length; i++) {
    const currentPoint = path[i];
    const distance = lastPoint.distance(currentPoint);

    // 如果距离超过最小距离，则保留该点
    if (distance >= minDistance) {
      simplified.push(currentPoint);
      lastPoint = currentPoint;
    }
  }

  // 确保包含最后一个点
  if (simplified[simplified.length - 1] !== path[path.length - 1]) {
    simplified.push(path[path.length - 1]);
  }

  // 根据距离限制最大点数
  let maxPoints;
  if (distanceKm <= 5) {
    maxPoints = 200; // 市区物流最多200个点
  } else if (distanceKm <= 50) {
    maxPoints = 150; // 省内物流最多150个点
  } else if (distanceKm <= 200) {
    maxPoints = 100; // 省内长距离最多100个点
  } else if (distanceKm <= 500) {
    maxPoints = 80; // 跨省物流最多80个点
  } else if (distanceKm <= 1000) {
    maxPoints = 50; // 跨省远距离最多50个点
  } else {
    maxPoints = 30; // 全国范围最多30个点
  }

  // 如果点数仍然过多，使用抽样方式进一步简化
  if (simplified.length > maxPoints) {
    const sampled = [];
    const step = Math.ceil(simplified.length / maxPoints);
    for (let i = 0; i < simplified.length; i += step) {
      sampled.push(simplified[i]);
    }
    // 确保包含最后一个点
    if (sampled[sampled.length - 1] !== simplified[simplified.length - 1]) {
      sampled.push(simplified[simplified.length - 1]);
    }
    return sampled;
  }

  return simplified;
};

// 规划驾车路线
const planDrivingRoute = (startLngLat, endLngLat) => {
  return new Promise((resolve, reject) => {
    if (driving && startLngLat && endLngLat) {
      driving.search(
          new window.AMap.LngLat(startLngLat.lng, startLngLat.lat),
          new window.AMap.LngLat(endLngLat.lng, endLngLat.lat),
          (status, result) => {
            if (status === 'complete') {
              currentRoute = result; // 保存当前路线
              // 显示路径长度
              showRouteDistance(result);
              ElMessage.success('驾车路线规划完成');
              resolve(result);
            } else {
              clearRouteDistance(); // 清除路径长度显示
              ElMessage.error('驾车路线规划失败: ' + result);
              reject(result);
            }
          }
      );
    } else {
      reject(new Error('路线规划服务未初始化或参数不完整'));
    }
  });
};

// 自动规划路线（当起点和终点都设置时调用）
const autoPlanRoute = () => {
  if (startMarker && destinationMarker && driving) {
    const startLngLat = startMarker.getPosition();
    const endLngLat = destinationMarker.getPosition();

    driving.search(
        startLngLat,
        endLngLat,
        (status, result) => {
          if (status === 'complete') {
            currentRoute = result; // 保存当前路线
            // 显示路径长度
            showRouteDistance(result);
            ElMessage.success('驾车路线已自动规划完成');
          } else {
            clearRouteDistance(); // 清除路径长度显示
            ElMessage.error('自动规划路线失败: ' + result);
          }
        }
    );
  }
};

// 开始轨迹动画
const startTrackAnimation = () => {
  return new Promise((resolve, reject) => {
    if (!currentRoute || !currentRoute.routes || currentRoute.routes.length === 0) {
      reject(new Error('没有可用的路线数据'));
      return;
    }

    // 清除之前的小车和动画
    if (carMarker) {
      carMarker.setMap(null);
      carMarker = null;
    }
    if (carAnimation) {
      carAnimation.stop();
      carAnimation = null;
    }

    // 清除之前的路径线
    if (passedPolyline) {
      passedPolyline.setMap(null);
      passedPolyline = null;
    }

    // 获取路线路径
    const route = currentRoute.routes[0];
    const path = [];
    route.steps.forEach(step => {
      path.push(...step.path);
    });

    // 使用 GeometryUtil 计算路径长度
    const distance = window.AMap.GeometryUtil.distanceOfLine(path);
    const distanceKm = distance / 1000;

    // 根据距离分情况简化路径点
    const simplifiedPath = simplifyPath(path, distanceKm);

    console.log(`原始路径点数量: ${path.length}`);
    console.log(`简化后路径点数量: ${simplifiedPath.length}`);

    // 根据距离分情况设置动画时间（进一步提速）
    let duration;
    if (distanceKm <= 5) {
      // 市区物流 - 极快动画（每公里0.01秒）
      duration = distanceKm * 10;
    } else if (distanceKm <= 50) {
      // 省内物流 - 快速动画（每公里0.02秒）
      duration = distanceKm * 20;
    } else if (distanceKm <= 200) {
      // 省内长距离 - 中等速度（每公里0.04秒）
      duration = distanceKm * 40;
    } else if (distanceKm <= 500) {
      // 跨省物流 - 较慢速度（每公里0.06秒）
      duration = distanceKm * 60;
    } else if (distanceKm <= 1000) {
      // 跨省远距离 - 慢速（每公里0.08秒）
      duration = distanceKm * 80;
    } else {
      // 全国范围 - 极慢速（每公里0.1秒）
      duration = distanceKm * 100;
    }

    // 确保最小时间
    if (duration < 30) {
      duration = 30;
    }

    // 确保最大时间不超过10秒（进一步提速）
    duration = Math.min(duration, 10000);

    console.log(`路线距离: ${distanceKm.toFixed(2)}公里`);
    console.log(`动画时间: ${duration}毫秒`);

    // 创建完整路径线（未走过，浅灰色）
    if (fullPolyline) {
      fullPolyline.setMap(null);
    }
    fullPolyline = new window.AMap.Polyline({
      map: map,
      path: simplifiedPath,
      strokeColor: "#CCCCCC", // 浅灰色表示未走过路径
      strokeWeight: 3, // 减小线条宽度
      strokeOpacity: 0.5 // 降低透明度
    });

    // 创建已走过路径线（深绿色）
    passedPolyline = new window.AMap.Polyline({
      map: map,
      strokeColor: "#228B22", // 深绿色表示已走过路径 (Forest Green)
      strokeWeight: 3,
      strokeOpacity: 0.5
    });

    // 创建小车图标 - 使用指定的图标
    carMarker = new window.AMap.Marker({
      map: map,
      position: simplifiedPath[0],
      icon: "https://a.amap.com/jsapi_demos/static/demo-center-v2/car.png",
      offset: new window.AMap.Pixel(-13, -26),
      autoRotation: true, // 随路径方向自动旋转
    });

    // 根据距离分情况设置更新频率（进一步提速）
    let lastUpdate = 0;
    let updateInterval;

    if (distanceKm <= 5) {
      // 市区物流 - 最高帧率（每5毫秒更新一次，约200帧/秒）
      updateInterval = 5;
    } else if (distanceKm <= 50) {
      // 省内物流 - 高帧率（每10毫秒更新一次，约100帧/秒）
      updateInterval = 10;
    } else if (distanceKm <= 200) {
      // 省内长距离 - 中等帧率（每20毫秒更新一次，约50帧/秒）
      updateInterval = 20;
    } else if (distanceKm <= 500) {
      // 跨省物流 - 较低帧率（每30毫秒更新一次，约33帧/秒）
      updateInterval = 30;
    } else {
      // 跨省远距离/全国范围 - 低帧率（每50毫秒更新一次，约20帧/秒）
      updateInterval = 50;
    }

    // 监听移动事件，更新已走过路径，但不移动地图中心
    carMarker.on('moving', (e) => {
      const now = Date.now();
      if (now - lastUpdate > updateInterval) {
        passedPolyline.setPath(e.passedPath);
        // 移除了 map.setCenter(e.target.getPosition()) 这一行，不再跟随小车移动地图中心
        lastUpdate = now;
      }
    });

    // 执行动画
    carMarker.moveAlong(simplifiedPath, {
      duration: duration,
      autoRotation: true
    });

    // 监听动画完成事件 - 只有到达目的地才显示提示
    carMarker.on('moveend', () => {
      // 检查小车是否真的到达了目的地
      if (destinationMarker && carMarker) {
        const carPosition = carMarker.getPosition();
        const destPosition = destinationMarker.getPosition();

        // 计算两点间距离，如果小于一定阈值则认为到达目的地
        const distance = carPosition.distance(destPosition);

        // 根据距离设置判断阈值
        let threshold;
        if (distanceKm <= 5) {
          threshold = 3; // 市区物流3米
        } else if (distanceKm <= 50) {
          threshold = 5; // 省内物流5米
        } else if (distanceKm <= 200) {
          threshold = 10; // 省内长距离10米
        } else if (distanceKm <= 500) {
          threshold = 15; // 跨省物流15米
        } else if (distanceKm <= 1000) {
          threshold = 25; // 跨省远距离25米
        } else {
          threshold = 40; // 全国范围40米
        }

        if (distance < threshold) {
          ElMessage.success('行程已完成');
        }
      }
      resolve();
    });
  });
};

// 显示路径长度 - 使用 GeometryUtil 计算
const showRouteDistance = (result) => {
  // 清除之前的距离标记
  clearRouteDistance();

  if (result.routes && result.routes.length > 0) {
    const route = result.routes[0]; // 获取第一条路线

    // 使用 GeometryUtil 计算路径长度
    const path = [];
    route.steps.forEach(step => {
      path.push(...step.path);
    });

    const distance = window.AMap.GeometryUtil.distanceOfLine(path); // 路线距离(米)

    // 获取路线终点作为距离标记的位置
    const steps = route.steps;
    if (steps && steps.length > 0) {
      const lastStep = steps[steps.length - 1];
      const lastPoint = lastStep.path[lastStep.path.length - 1];

      // 创建距离文本标记
      distanceText = new window.AMap.Text({
        position: [lastPoint.lng, lastPoint.lat],
        text: `路程: ${Math.round(distance / 100) / 10}公里`,
        offset: new window.AMap.Pixel(-20, -20),
        style: {
          'background': 'rgba(0,0,0,0.7)',
          'color': 'white',
          'padding': '2px 6px',
          'border-radius': '4px',
          'font-size': '12px'
        }
      });

      distanceText.setMap(map);
    }
  }
};

// 清除路径长度显示
const clearRouteDistance = () => {
  if (distanceText) {
    distanceText.setMap(null);
    distanceText = null;
  }
};

// 清除起点标记
const clearStartMarker = () => {
  if (startMarker) {
    startMarker.setMap(null);
    startMarker = null;
    ElMessage.info('已清除起点标记');
  }
};

// 清除目的地标记
const clearDestinationMarker = () => {
  if (destinationMarker) {
    destinationMarker.setMap(null);
    destinationMarker = null;
    ElMessage.info('已清除目的地标记');
  }
};

// 清除所有标记
const clearMarkers = () => {
  // 清除起点标记
  if (startMarker) {
    startMarker.setMap(null);
    startMarker = null;
  }

  // 清除目的地标记
  if (destinationMarker) {
    destinationMarker.setMap(null);
    destinationMarker = null;
  }

  // 清除驾车路线
  if (driving) {
    driving.clear();
  }

  // 清除路径长度显示
  clearRouteDistance();

  // 清除小车和动画
  if (carMarker) {
    carMarker.setMap(null);
    carMarker = null;
  }
  if (carAnimation) {
    carAnimation.stop();
    carAnimation = null;
  }

  // 清除路径线
  if (fullPolyline) {
    fullPolyline.setMap(null);
    fullPolyline = null;
  }
  if (passedPolyline) {
    passedPolyline.setMap(null);
    passedPolyline = null;
  }

  // 清除当前路线
  currentRoute = null;

  ElMessage.info('已清除所有标记');
};

// 获取起点标记信息
const getStartMarkerInfo = () => {
  if (startMarker) {
    const position = startMarker.getPosition();
    return {
      lng: position.lng,
      lat: position.lat
    };
  }
  return null;
};

// 获取目的地标记信息
const getDestinationMarkerInfo = () => {
  if (destinationMarker) {
    const position = destinationMarker.getPosition();
    return {
      lng: position.lng,
      lat: position.lat
    };
  }
  return null;
};

// 获取地图实例
const getMap = () => map;

defineExpose({
  getMap,
  addStartMarker,
  addDestinationMarker,
  clearStartMarker,
  clearDestinationMarker,
  clearMarkers,
  getStartMarkerInfo,
  getDestinationMarkerInfo,
  planDrivingRoute,
  autoPlanRoute,
  startTrackAnimation
});
</script>

<style scoped>
#container {
  width: 100%;
  height: 100%;
  position: relative;
}

/* 删除提示信息样式 */
/*
.map-tip {
  position: absolute;
  top: 50px;
  left: 10px;
  background: rgba(0, 0, 0, 0.7);
  color: white;
  padding: 5px 10px;
  border-radius: 4px;
  font-size: 12px;
  z-index: 10;
}
*/
</style>
